const fs = require('fs');
const xlsx = require('xlsx');
const axios = require('axios');
const path = require('path');

// 加载环境变量
require('dotenv').config();

// 企业微信Webhook地址
const WECHAT_WEBHOOK = process.env.WECHAT_WEBHOOK;

// API请求延迟配置（毫秒）
const REQUEST_DELAY = parseInt(process.env.REQUEST_DELAY) || 5000;

// 定时检查间隔配置（毫秒）
const CHECK_INTERVAL = (parseInt(process.env.CHECK_INTERVAL_MINUTES) || 20) * 60 * 1000;

// 检查必要的环境变量
if (!WECHAT_WEBHOOK) {
    console.error('❌ 错误：未找到企业微信Webhook地址');
    console.error('请先复制 .env.example 文件为 .env 并配置 WECHAT_WEBHOOK');
    process.exit(1);
}

// 状态文件路径
const STATUS_FILE = process.env.NODE_ENV === 'production' ? '/app/data/task_status.json' : './task_status.json';
// 每日统计文件路径
const DAILY_STATS_FILE = process.env.NODE_ENV === 'production' ? '/app/data/daily_stats.json' : './daily_stats.json';

// 读取Excel文件
async function readExcelFile(filePath) {
    try {
        const workbook = xlsx.readFile(filePath);
        const sheetName = workbook.SheetNames[0]; // 读取第一个工作表
        const worksheet = workbook.Sheets[sheetName];
        const data = xlsx.utils.sheet_to_json(worksheet);
        return data;
    } catch (error) {
        console.error('读取Excel文件失败:', error.message);
        return [];
    }
}

// 发送API请求获取任务详情
async function getTaskDetail(id) {
    try {
        const url = `https://api-pre.prover.xyz/api/v1/zkTask/dashboard/prover/detail/${id}`;
        const response = await axios.get(url);
        return response.data;
    } catch (error) {
        console.error(`获取ID ${id} 的任务详情失败:`, error.message);
        return null;
    }
}

// 发送企业微信消息
async function sendWeChatMessage(message) {
    try {
        const data = {
            msgtype: 'text',
            text: {
                content: message
            }
        };
        
        const response = await axios.post(WECHAT_WEBHOOK, data, {
            headers: {
                'Content-Type': 'application/json'
            }
        });
        
        if (response.data.errcode === 0) {
            console.log('✅ 企业微信消息发送成功');
            return true;
        } else {
            console.error('❌ 企业微信消息发送失败:', response.data);
            return false;
        }
    } catch (error) {
        console.error('❌ 发送企业微信消息出错:', error.message);
        return false;
    }
}

// 读取任务状态
function readTaskStatus() {
    try {
        if (fs.existsSync(STATUS_FILE)) {
            const data = fs.readFileSync(STATUS_FILE, 'utf8');
            return JSON.parse(data);
        }
    } catch (error) {
        console.error('读取状态文件失败:', error.message);
    }
    return {};
}

// 保存任务状态
function saveTaskStatus(status) {
    try {
        fs.writeFileSync(STATUS_FILE, JSON.stringify(status, null, 2));
    } catch (error) {
        console.error('保存状态文件失败:', error.message);
    }
}

// 检查是否有新任务
function hasNewTasks(totalTask, finishTask) {
    return totalTask > finishTask;
}

// 打印任务信息
function printTaskInfo(data, id, deviceName, previousDevice = null) {
    if (!data || data.code !== 0) {
        const statusInfo = previousDevice ? 
            (previousDevice.success ? ' (之前请求成功)' : ' (之前也请求失败)') : 
            ' (首次请求)';
        console.log(`\n❌ ID: ${id} - 获取数据失败${statusInfo}`);
        return;
    }

    const taskData = data.data;
    const hasNewTask = hasNewTasks(taskData.totalTask, taskData.finishTask);
    
    // 分析状态变化
    let statusChange = '';
    if (previousDevice && previousDevice.success) {
        if (previousDevice.hasNewTask && !hasNewTask) {
            statusChange = ' (✅ 任务完成了)';
        } else if (!previousDevice.hasNewTask && hasNewTask) {
            statusChange = ' (🆕 新增任务)';
        } else if (previousDevice.totalTask !== taskData.totalTask) {
            statusChange = ` (📈 任务数变化: ${previousDevice.totalTask}→${taskData.totalTask})`;
        }
    } else if (previousDevice && !previousDevice.success) {
        statusChange = ' (🔄 请求恢复正常)';
    }
    
    console.log(`\n📊 设备信息 - ID: ${id}${statusChange}`);
    console.log(`   设备名: ${deviceName || 'N/A'}`);
    console.log(`   总分: ${taskData.rewardCYS} CYS`);
    console.log(`   总任务数: ${taskData.totalTask}`);
    console.log(`   完成任务数: ${taskData.finishTask}`);
    console.log(`   完成率: ${taskData.totalTask > 0 ? ((taskData.finishTask / taskData.totalTask) * 100).toFixed(2) : 0}%`);
    console.log(`   状态: ${taskData.status === 1 ? '正常' : '异常'}`);
    console.log(`   新任务: ${hasNewTask ? '🔔 有新任务' : '✅ 无新任务'}`);
}

// 读取每日统计数据
function readDailyStats() {
    try {
        if (fs.existsSync(DAILY_STATS_FILE)) {
            const data = fs.readFileSync(DAILY_STATS_FILE, 'utf8');
            return JSON.parse(data);
        }
    } catch (error) {
        console.error('读取每日统计文件失败:', error.message);
    }
    return {};
}

// 保存每日统计数据
function saveDailyStats(stats) {
    try {
        fs.writeFileSync(DAILY_STATS_FILE, JSON.stringify(stats, null, 2));
    } catch (error) {
        console.error('保存每日统计文件失败:', error.message);
    }
}

// 获取今天的日期字符串
function getTodayString() {
    const today = new Date();
    return today.toISOString().split('T')[0]; // YYYY-MM-DD格式
}

// 更新设备每日统计
function updateDailyStats(deviceId, deviceName, currentTaskData, previousTaskData) {
    const dailyStats = readDailyStats();
    const today = getTodayString();
    
    // 初始化设备统计
    if (!dailyStats[deviceId]) {
        dailyStats[deviceId] = {
            deviceName: deviceName || `设备${deviceId}`,
            history: {}
        };
    }
    
    // 初始化今天的统计
    if (!dailyStats[deviceId].history[today]) {
        dailyStats[deviceId].history[today] = {
            received: 0,    // 当天接收的任务数
            completed: 0,   // 当天完成的任务数
            failed: 0,      // 当天失败的任务数
            totalTaskStart: currentTaskData.totalTask,     // 当天开始时的总任务数
            finishTaskStart: currentTaskData.finishTask,   // 当天开始时的完成任务数
            lastTotalTask: currentTaskData.totalTask,      // 最后记录的总任务数
            lastFinishTask: currentTaskData.finishTask     // 最后记录的完成任务数
        };
    }
    
    const todayStats = dailyStats[deviceId].history[today];
    
    if (previousTaskData && previousTaskData.success) {
        // 检查任务总数变化
        const totalTaskChange = currentTaskData.totalTask - previousTaskData.totalTask;
        const finishTaskChange = currentTaskData.finishTask - previousTaskData.finishTask;
        
        if (totalTaskChange > 0) {
            // 任务总数增加，说明接收了新任务
            todayStats.received += totalTaskChange;
            console.log(`   📈 设备${deviceId}接收了${totalTaskChange}个新任务`);
        } else if (totalTaskChange < 0) {
            // 任务总数减少，说明任务被收回（失败）
            const failedTasks = Math.abs(totalTaskChange);
            todayStats.failed += failedTasks;
            console.log(`   ❌ 设备${deviceId}有${failedTasks}个任务被收回（失败）`);
        }
        
        if (finishTaskChange > 0) {
            // 完成任务数增加
            todayStats.completed += finishTaskChange;
            console.log(`   ✅ 设备${deviceId}完成了${finishTaskChange}个任务`);
        }
    }
    
    // 更新最后记录的数值
    todayStats.lastTotalTask = currentTaskData.totalTask;
    todayStats.lastFinishTask = currentTaskData.finishTask;
    
    // 更新设备名（可能会变化）
    dailyStats[deviceId].deviceName = deviceName || `设备${deviceId}`;
    
    saveDailyStats(dailyStats);
    
    return todayStats;
}

// 打印每日统计信息
function printDailyStatsInfo(deviceId, todayStats) {
    if (todayStats.received > 0 || todayStats.completed > 0 || todayStats.failed > 0) {
        console.log(`   📊 今日统计: 接收${todayStats.received}个 | 完成${todayStats.completed}个 | 失败${todayStats.failed}个`);
    }
}

// 获取所有设备今日统计汇总
function getDailyStatsSummary() {
    const dailyStats = readDailyStats();
    const today = getTodayString();
    
    let summary = {
        totalReceived: 0,
        totalCompleted: 0,
        totalFailed: 0,
        deviceCount: 0,
        activeDevices: []
    };
    
    Object.keys(dailyStats).forEach(deviceId => {
        const device = dailyStats[deviceId];
        if (device.history[today]) {
            const todayData = device.history[today];
            summary.totalReceived += todayData.received;
            summary.totalCompleted += todayData.completed;
            summary.totalFailed += todayData.failed;
            summary.deviceCount++;
            
            if (todayData.received > 0 || todayData.completed > 0 || todayData.failed > 0) {
                summary.activeDevices.push({
                    id: deviceId,
                    name: device.deviceName,
                    received: todayData.received,
                    completed: todayData.completed,
                    failed: todayData.failed
                });
            }
        }
    });
    
    return summary;
}

// 清理旧的统计数据（保留最近30天）
function cleanOldStats() {
    try {
        const dailyStats = readDailyStats();
        const today = new Date();
        const thirtyDaysAgo = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000);
        const cutoffDate = thirtyDaysAgo.toISOString().split('T')[0];
        
        let cleaned = false;
        Object.keys(dailyStats).forEach(deviceId => {
            const device = dailyStats[deviceId];
            const oldDates = Object.keys(device.history).filter(date => date < cutoffDate);
            
            if (oldDates.length > 0) {
                oldDates.forEach(date => {
                    delete device.history[date];
                });
                cleaned = true;
            }
        });
        
        if (cleaned) {
            saveDailyStats(dailyStats);
            console.log('✅ 已清理30天前的统计数据');
        }
    } catch (error) {
        console.error('清理旧统计数据失败:', error.message);
    }
}

// 获取指定设备的历史统计
function getDeviceHistory(deviceId, days = 7) {
    const dailyStats = readDailyStats();
    if (!dailyStats[deviceId]) {
        return null;
    }
    
    const device = dailyStats[deviceId];
    const today = new Date();
    const history = [];
    
    for (let i = days - 1; i >= 0; i--) {
        const date = new Date(today.getTime() - i * 24 * 60 * 60 * 1000);
        const dateString = date.toISOString().split('T')[0];
        
        if (device.history[dateString]) {
            history.push({
                date: dateString,
                ...device.history[dateString]
            });
        } else {
            history.push({
                date: dateString,
                received: 0,
                completed: 0,
                failed: 0
            });
        }
    }
    
    return {
        deviceId: deviceId,
        deviceName: device.deviceName,
        history: history
    };
}

// 主函数
async function main(isFirstRun = false) {
    console.log(`🚀 ${isFirstRun ? '首次运行' : '定时检查'} - 开始检查任务状态... ${new Date().toLocaleString()}`);
    console.log(`⏱️ API请求延迟设置: ${REQUEST_DELAY}ms`);
    if (isFirstRun) {
        console.log(`🕒 定时检查间隔: ${process.env.CHECK_INTERVAL_MINUTES || 20}分钟`);
    }
    console.log('');

    // 读取Excel文件
    const excelData = await readExcelFile('./device.xlsx');
    
    if (excelData.length === 0) {
        console.error('Excel文件为空或读取失败');
        return;
    }

    console.log(`📋 从Excel文件中读取到 ${excelData.length} 条记录`);

    // 找到包含ID的列
    const idField = Object.keys(excelData[0]).find(key => 
        key.toLowerCase().includes('id') || 
        key.includes('设备') ||
        typeof excelData[0][key] === 'number'
    );

    // 找到device字段
    const deviceField = Object.keys(excelData[0]).find(key => 
        key.toLowerCase().includes('device') || 
        key.includes('设备名') ||
        key.includes('名称')
    );

    if (!idField) {
        console.error('未找到ID字段，请检查Excel文件结构');
        console.log('Excel文件的列名:', Object.keys(excelData[0]));
        return;
    }

    console.log(`📍 使用字段: ${idField} 作为设备ID`);
    console.log(`📍 使用字段: ${deviceField || '未找到device字段'} 作为设备名\n`);

    // 读取之前的任务状态
    const previousStatus = readTaskStatus();
    const currentStatus = {};

    // 统计信息
    let totalDevices = 0;
    let successCount = 0;
    let totalRewardCYS = 0;
    let totalTasks = 0;
    let totalFinishedTasks = 0;
    let newTaskDevices = []; // 有新任务的设备

    // 遍历每个设备ID并获取任务详情
    for (const row of excelData) {
        const deviceId = row[idField];
        const deviceName = deviceField ? row[deviceField] : null;
        if (!deviceId) continue;

        totalDevices++;
        
        const taskDetail = await getTaskDetail(deviceId);
        const previousDevice = previousStatus[deviceId];
        
        if (taskDetail && taskDetail.code === 0) {
            // 请求成功的情况
            successCount++;
            const data = taskDetail.data;
            totalRewardCYS += parseFloat(data.rewardCYS || 0);
            totalTasks += parseInt(data.totalTask || 0);
            totalFinishedTasks += parseInt(data.finishTask || 0);
            
            // 检查是否有新任务
            const hasNewTask = hasNewTasks(data.totalTask, data.finishTask);
            
            // 更新每日统计数据
            const todayStats = updateDailyStats(deviceId, deviceName, data, previousDevice);
            
            // 记录当前状态（成功状态）
            currentStatus[deviceId] = {
                success: true,
                totalTask: data.totalTask,
                finishTask: data.finishTask,
                hasNewTask: hasNewTask,
                deviceName: deviceName || `设备${deviceId}`,
                lastUpdateTime: new Date().toISOString()
            };
            
            // 检查是否需要通知（只有在之前也是成功状态时才比较）
            let shouldNotify = false;
            
            if (hasNewTask) {
                if (isFirstRun) {
                    // 首次运行且有新任务
                    shouldNotify = true;
                } else if (previousDevice && previousDevice.success) {
                    // 之前请求成功，现在也成功，比较状态变化
                    shouldNotify = !previousDevice.hasNewTask; // 之前没有新任务，现在有了
                } else if (!previousDevice) {
                    // 之前没有任何记录（真正的新设备）
                    shouldNotify = true;
                }
                // 如果之前请求失败（previousDevice.success = false），现在成功了，不通知
                // 避免因为网络问题导致的误报
            }
            
            if (shouldNotify) {
                newTaskDevices.push({
                    id: deviceId,
                    name: deviceName || `设备${deviceId}`,
                    totalTask: data.totalTask,
                    finishTask: data.finishTask,
                    pendingTask: data.totalTask - data.finishTask
                });
            }
        } else {
            // 请求失败的情况，也要记录状态
            currentStatus[deviceId] = {
                success: false,
                deviceName: deviceName || `设备${deviceId}`,
                lastUpdateTime: new Date().toISOString(),
                error: '请求失败'
            };
        }
        
        printTaskInfo(taskDetail, deviceId, deviceName, previousDevice);
        
        // 如果请求成功，打印每日统计信息
        if (taskDetail && taskDetail.code === 0) {
            const dailyStats = readDailyStats();
            const today = getTodayString();
            if (dailyStats[deviceId] && dailyStats[deviceId].history[today]) {
                printDailyStatsInfo(deviceId, dailyStats[deviceId].history[today]);
            }
        }
        
        // 添加延迟避免请求过于频繁
        await new Promise(resolve => setTimeout(resolve, REQUEST_DELAY)); // 可配置延迟，避免403错误
    }

    // 保存当前状态
    saveTaskStatus(currentStatus);

    // 发送企业微信通知
    if (newTaskDevices.length > 0) {
        let message = `🔔 Cysic任务监控提醒\n\n`;
        message += `发现 ${newTaskDevices.length} 个设备有新任务：\n\n`;
        
        newTaskDevices.forEach((device, index) => {
            message += `${index + 1}. ${device.name} (ID: ${device.id})\n`;
            message += `   待完成任务: ${device.pendingTask} 个\n`;
            message += `   总任务: ${device.totalTask} | 已完成: ${device.finishTask}\n\n`;
        });
        
        message += `检查时间: ${new Date().toLocaleString()}`;
        
        console.log('\n🔔 发送企业微信通知...');
        await sendWeChatMessage(message);
    } else {
        console.log('\n✅ 暂无新任务需要通知');
    }

    // 获取今日统计汇总
    const dailySummary = getDailyStatsSummary();
    
    // 打印汇总信息
    console.log('\n' + '='.repeat(50));
    console.log('📈 汇总统计');
    console.log('='.repeat(50));
    console.log(`总设备数: ${totalDevices}`);
    console.log(`成功获取数据: ${successCount}/${totalDevices}`);
    console.log(`请求失败设备数: ${totalDevices - successCount}`);
    console.log(`总奖励 CYS: ${totalRewardCYS.toFixed(2)}`);
    console.log(`总任务数: ${totalTasks}`);
    console.log(`总完成任务数: ${totalFinishedTasks}`);
    console.log(`整体完成率: ${totalTasks > 0 ? ((totalFinishedTasks / totalTasks) * 100).toFixed(2) : 0}%`);
    console.log(`有新任务设备数: ${newTaskDevices.length}`);
    if (newTaskDevices.length > 0) {
        console.log(`通知设备列表: ${newTaskDevices.map(d => `${d.name}(${d.id})`).join(', ')}`);
    }
    
    // 打印今日统计汇总
    console.log('\n' + '='.repeat(50));
    console.log('📊 今日任务统计汇总');
    console.log('='.repeat(50));
    console.log(`今日接收任务总数: ${dailySummary.totalReceived}`);
    console.log(`今日完成任务总数: ${dailySummary.totalCompleted}`);
    console.log(`今日失败任务总数: ${dailySummary.totalFailed}`);
    console.log(`今日活跃设备数: ${dailySummary.activeDevices.length}`);
    
    if (dailySummary.activeDevices.length > 0) {
        console.log('\n📋 今日活跃设备详情:');
        dailySummary.activeDevices.forEach((device, index) => {
            console.log(`${index + 1}. ${device.name} (ID: ${device.id})`);
            console.log(`   接收: ${device.received} | 完成: ${device.completed} | 失败: ${device.failed}`);
        });
    }
    
    console.log('\n✅ 任务检查完成！');
}

// 启动监控
async function startMonitoring() {
    console.log('🎯 启动Cysic任务监控系统...\n');
    
    // 首次运行时清理旧数据
    cleanOldStats();
    
    // 首次运行
    await main(true);
    
    // 设置定时任务，根据配置间隔运行
    setInterval(async () => {
        console.log('\n' + '='.repeat(60));
        await main(false);
    }, CHECK_INTERVAL); // 可配置的检查间隔
    
    // 设置每日清理任务（每24小时清理一次旧数据）
    setInterval(() => {
        cleanOldStats();
    }, 24 * 60 * 60 * 1000); // 24小时
    
    console.log(`\n⏰ 定时监控已启动，每${process.env.CHECK_INTERVAL_MINUTES || 20}分钟检查一次任务状态...`);
    console.log('📊 每日统计数据会自动保存到 daily_stats.json 文件中');
    console.log('🗑️  系统会自动清理30天前的统计数据');
    console.log('按 Ctrl+C 停止监控\n');
}

// 运行脚本
startMonitoring().catch(error => {
    console.error('脚本执行出错:', error);
}); 